///**
// * @author hr
// * @date 2020年5月20日
// */
//package com.whfp.coky.ble.utils;
//
//import androidx.annotation.IntRange;
//
//import com.blankj.utilcode.util.StringUtils;
//import com.whfp.afs330h_sdk.utils.RxHexTool;
//import com.whfp.coky.utils.LogUtil;
//
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//
//
///**
// * 物证箱协议解析辅助类
// */
//public class WzxDataHelper {
//    //加密标识异或值
//    public static final String XOR_FLAG = "0x55";
//
//    /**
//     * 判断是否都是数字
//     *
//     * @param data
//     * @return
//     */
//    public static boolean checkIsOrNotContains(String data) {
//
//        return data.matches("\\d{1,}");
//    }
//
//    /**
//     * 检查数据个数是否是双数
//     *
//     * @param data
//     * @return
//     */
//    public static boolean checkIsOrNotEven(String data) {
//        data = data.replaceAll("\\s{1,}", "");
//        int model = data.length() % 2;
//        if (model != 0) {
//            return false;
//        }
//        return true;
//    }
//
//    /**
//     * 将原始16进制协议数据转换为char字符数据
//     *
//     * @param data 原始GPRS协议数据  示例:4135303030303030303031324237
//     * @return 16进制hex数据    对应示例值:A50000000012B7
//     */
//    public static String changeHexToChar(String data) {
//
//        Character[] pbSrc = new Character[data.length()];
//        for (int i = 0; i < data.length(); i++) {
//            pbSrc[i] = data.charAt(i);
//        }
//        StringBuffer temp = new StringBuffer();
//        for (int i = 0; i < pbSrc.length / 2; i++) {
//            temp.append((char) Integer.parseInt(pbSrc[2 * i] + "" + pbSrc[2 * i + 1], 16));
//        }
//        //将转换完的数据中包含的异常符号全部去除
//        return temp.toString().replaceAll("\\s{1,}", "");
//    }
//
//    /**
//     * 20200523 由于硬件厂商发送的协议格式发生变动故添加此方法进行数据再次封装
//     * 0xa5 0x00 0x00 0x00 0x00 0x12 0x00 0xB7 ----> a5000000001200B7
//     *
//     * @param data 原始协议数据
//     * @return 返回为16进制带空格的协议数据
//     */
//    public static String getOrgData(String data) {
//        //去掉可能包含的异常符号
//        data = data.replaceAll("\\s{1,}", "");
//        StringBuffer temp = new StringBuffer("");
//        for (int i = 0; i < data.length() / 2; i++) {
//            temp.append(data.charAt(2 * i) + "" + data.charAt(2 * i + 1));
//            temp.append(" ");//拼接上空格，恢复到改动之前的格式
//        }
//        return temp.toString();
//    }
//
//
//    /**
//     * 对16进制数据进行异或处理
//     *
//     * @param data
//     * @return
//     */
//    public static String xorData(String data) {
//        if (StringUtils.isEmpty(data)) {
//            LogUtil.INSTANCE.e("数据不可为空！");
//            return null;
//        }
//        if (!checkIsOrNotEven(data)) {
//            LogUtil.INSTANCE.e("要计算的16进制字符串不正确！");
//            return null;
//        }
//        String str = getOrgData(data);
//        String[] info = str.split(" {1,}");//以空格进行截取
//        StringBuffer msg = new StringBuffer();
//        for (int i = 0; i < info.length; i++) {//数据区从第7位到倒数第三位，长度为动态 如果数据区长度为0 则表示没有数据区数据
//            //协议数据区数据是进行亦或加密处理，需要再进行异或获取真实值
//            msg.append(getRealData(info[i], XOR_FLAG));
////            msg.append(" ");//应用层协议字节可能达到1000，这里有数据需要另外解析处理，所以暂时用空格隔离保持原数据格式
//        }
//        return msg.toString();
//    }
//
//
//    /**
//     * 解析按位异或后的加密数据，获取真实数据(篾子只能异或一个字节的数据)
//     *
//     * @param orgData  加密前的协议数据
//     * @param xor_flag 加密标识异或值
//     * @return 协议所带的真实的16进制值
//     */
//    public static String getRealData(String orgData, String xor_flag) {
//        //如果有16进制标识，则去掉
//        orgData = orgData.replaceAll("0x", "");
//        xor_flag = xor_flag.replaceAll("0x", "");
//        //转成二进制形式
//        String anotherBinary = Integer.toBinaryString(Integer.valueOf(orgData, 16));
//        String thisBinary = Integer.toBinaryString(Integer.valueOf(xor_flag, 16));
//        String result = "";
//        //判断是否为8位二进制，否则左补零
//        if (anotherBinary.length() != 8) {
//            for (int i = anotherBinary.length(); i < 8; i++) {
//                anotherBinary = "0" + anotherBinary;
//            }
//        }
//        if (thisBinary.length() != 8) {
//            for (int i = thisBinary.length(); i < 8; i++) {
//                thisBinary = "0" + thisBinary;
//            }
//        }
//        //异或运算
//        for (int i = 0; i < anotherBinary.length(); i++) {
//            //如果相同位置数相同，则补0，否则补1
//            if (thisBinary.charAt(i) == anotherBinary.charAt(i)) {
//                result += "0";
//            } else {
//                result += "1";
//            }
//        }
//        //2进制再转换为16进制
//        String temp = Integer.toHexString(Integer.parseInt(result, 2));
//        if (temp.length() < 2) {
//            //如果计算后16进制只有一位，则前面补0
//            temp = "0" + temp;
//        }
//        return temp;
//    }
//
//    /**
//     * 提取出物证箱ID
//     *
//     * @param wzxStr 发送获取物证箱ID指令返回的信息字符串
//     * @return
//     */
//    public static String getWzxID(String wzxStr) {
////        //获取当前信息字符串需要去掉几个校验位
////        int jyw = wzxStr.length() / 2 / 20;
//        StringBuilder sb = new StringBuilder(wzxStr);
//        for (int i = wzxStr.length(); i >= 40; i = i - 40) {
//            sb.replace(i - 2, i, "");
//        }
//        String idInfo = sb.toString();
//        //物证箱id的长度
//        int idLength = AccountHelper.StringToLong(idInfo.substring(8, 10), 16).intValue();
//        LogUtil.INSTANCE.i("物证箱ID长度：" + idLength);
//        String id = idInfo.substring(10, 10 + (idLength * 2));
//        LogUtil.INSTANCE.i("处理完之后的物证箱ID信息:" + id);
//        return id;
//    }
//
//    /**
//     * 计算帧数
//     *
//     * @param z 将要发送的指令
//     * @return 返回16进制数的帧数
//     */
//    public static String getZx(String z) {
//        double zx = Math.ceil((z.length() / 2) * 1.0 / 19);
//        LogUtil.INSTANCE.i("未处理前的帧数：" + zx);
//        String zxStr = String.valueOf((int) zx);
//        if (zxStr.length() < 2) {
//            zxStr = "0" + zxStr;
//        }
//        LogUtil.INSTANCE.i("计算出来的帧数：" + zxStr);
//        return zxStr;
//    }
//
//    /**
//     * 获取16进制字符串的字节长度
//     *
//     * @param str        要计算的字符串
//     * @param byteNumber 返回的字符串字节数
//     * @return
//     */
//    public static String getBytesLength(String str, @IntRange(from = 1, to = 2) int byteNumber) {
//        if (StringUtils.isEmpty(str)) {
//            LogUtil.INSTANCE.e("数据不可为空！");
//            return null;
//        }
//        if (!checkIsOrNotEven(str)) {
//            LogUtil.INSTANCE.e("要计算的16进制字符串不正确！");
//            return null;
//        }
//        String lengthString = AccountHelper.IntergerToOther(str.length() / 2, 16);
//        if (byteNumber == 1) {
//            if (lengthString.length() == 1) {
//                lengthString = "0" + lengthString;
//            }
//        } else {
//            if (lengthString.length() == 1) {
//                lengthString = "000" + lengthString;
//            } else if (lengthString.length() == 2) {
//                lengthString = "00" + lengthString;
//            } else if (lengthString.length() == 3) {
//                lengthString = "0" + lengthString;
//            }
//        }
//        LogUtil.INSTANCE.i("计算出的16进制字符串的字节长度是：" + lengthString);
//        return lengthString;
//    }
//
//    /**
//     * 开箱密码处理
//     *
//     * @param str
//     * @return
//     */
//    public static String getUnBoxingPassword(String str) {
//        if (StringUtils.isEmpty(str)) {
//            LogUtil.INSTANCE.e("密码不可为空！");
//            return null;
//        }
//        if (str.equals("000000000000")) {
//            return str;
//        } else {
//            //字符串转ASCII码
////            StringBuffer sb = new StringBuffer();
////            for (int i = 0; i < str.length(); i++) {
////                sb.append(RxHexTool.stringToAscii(String.valueOf(str.charAt(i))));
////            }
////            LogUtil.INSTANCE.i("转成ASCII码后的密码：" + sb.toString());
////            return sb.toString();
//            //字符串转16进制 2020-08-11日协议规则改变
//            return RxHexTool.str2HexStr(str);
//        }
//    }
//
//
//    /**
//     * 获取指令头
//     *
//     * @param str 运用层已解析过的数据
//     * @return
//     */
//    public static String getInstructionHeader(String str) {
//        if (StringUtils.isEmpty(str)) {
//            LogUtil.INSTANCE.e("运用层帧数据不可为空！");
//            return null;
//        }
//        if (!checkIsOrNotEven(str)) {
//            LogUtil.INSTANCE.e("运用层帧数据不正确！");
//            return null;
//        }
//
//        String[] info = str.split(" {1,}");//以空格进行截取
//        return info[0];
//    }
//
//
//    /**
//     * 获取设备ID与设备验证码
//     *
//     * @param data 发送获【获取ID】指令返回得到的【箱体押运信息】原始报文
//     * @return 包含设备ID与设备验证码信息的map
//     */
//    public static Map<String, String> getDeviceIdAndCheckCode(String data) {
//        if (StringUtils.isEmpty(data)) {
//            LogUtil.INSTANCE.e("物理层帧数据不可为空！");
//            return null;
//        }
//        if (!checkIsOrNotEven(data)) {
//            LogUtil.INSTANCE.e("物理层帧数据不正确！");
//            return null;
//        }
//        String d = getOrgData(data);
//        Map<String, String> map_wlc = WzxDataHelper.getOrgAllData(d);
//        Map<String, String> map_yxc = WzxDataHelper.getOrgUseData(map_wlc.get("data"));
//        return map_yxc;
//    }
//
//    /**
//     * 获取校验位
//     *
//     * @param data 物理层原始数据帧
//     * @return
//     */
//    public static String getCheckDigit(String data) {
//        if (StringUtils.isEmpty(data)) {
//            LogUtil.INSTANCE.e("物理层帧数据不可为空！");
//            return null;
//        }
//        if (!checkIsOrNotEven(data)) {
//            LogUtil.INSTANCE.e("物理层帧数据不正确！");
//            return null;
//        }
//        String d = getOrgData(data);
//        LogUtil.INSTANCE.i("这里的数据是：" + d);
//        String[] info = d.split(" {1,}");//以空格进行截取
//        Long result = 0L;
//        //除去后两位校验和数据，累加求和
//        for (int i = 0; i < info.length; i++) {
//            result = result + AccountHelper.StringToLong(info[i].replaceAll("0x", ""), 16);//去掉16进制标识0x
//        }
//        LogUtil.INSTANCE.i("计算出来的10进制：" + result);
//        String jyw = AccountHelper.IntergerToOther(Integer.valueOf(result.toString()), 16);
//        LogUtil.INSTANCE.i("计算出的校验位：" + jyw);
//        if (jyw.length() == 3) {
//            jyw = "0" + jyw;
//        } else if (jyw.length() == 2) {
//            jyw = "00" + jyw;
//        } else if (jyw.length() == 1) {
//            jyw = "000" + jyw;
//        }
//        return jyw;
//    }
//
//
//    /**
//     * 发送超过20字节的指令处理
//     *
//     * @param instruction 要处理的指令
//     * @return
//     */
//    public static String instructionProcess(String instruction) {
//        String addSpaceStr = addSpace(instruction);
//        String[] info = addSpaceStr.split(" {1,}");//以空格进行截取
//        StringBuffer sb = new StringBuffer("");
//        for (int i = 0; i < info.length; i++) {
//            if (i + 1 == info.length && info[i].length() < (19 * 2)) {
//                sb.append(zdbl(info[i]) + RxHexTool.makeCheckSum(info[i]));
//            } else {
//                sb.append(info[i] + RxHexTool.makeCheckSum(info[i]));
//            }
//        }
//        String clwb = sb.toString();
//        LogUtil.INSTANCE.i("处理完的指令：" + clwb);
//        return clwb;
//    }
//
//    /**
//     * 每隔38个字符加一个空格
//     */
//    public static String addSpace(String str) {
//        int length = str.length();
//        String str1 = "";
//        for (int i = 0; i < length; i++) {
//            if (i * 38 + 38 > str.length()) {
//                str1 += str.substring(i * 38, length);
//                break;
//            }
//            str1 += str.substring(i * 38, i * 38 + 38) + " ";
//        }
//        if (str1.endsWith(" ")) {
//            str1 = str1.substring(0, length - 1);
//        }
//        LogUtil.INSTANCE.i("添加完空格之后：" + str1);
//        return str1;
//    }
//
//
//    /**
//     * 物证箱指令自动补位
//     *
//     * @param str
//     * @return
//     */
//    public static String zdbl(String str) {
//        int i = 19;
//        //需要补多少位0
//        int j = i - (str.length() / 2);
//        LogUtil.INSTANCE.i("需要补" + j + "位00");
//        String t = "";
//        if (j > 0) {
//            StringBuffer sb = new StringBuffer("");
//            for (int k = 0; k < j; k++) {
//                sb.append("00");
//            }
//            t = sb.toString();
//        }
//        String x = str + t;
//        LogUtil.INSTANCE.i("补位完成后：" + x);
//        return x;
//    }
//
//
//    /**
//     * 对物理层原始帧协议进行校验
//     *
//     * @param data 物理层原始帧协议数据
//     * @return 校验通过返回true，反之false
//     */
//    public static boolean getDataCheckResult(String data) {
//        if (StringUtils.isEmpty(data)) {
//            return false;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        Long result = 0L;
//        //除去后两位校验和数据，累加求和
//        for (int i = 0; i < info.length - 2; i++) {
//            result = result + AccountHelper.StringToLong(info[i].replaceAll("0x", ""), 16);//去掉16进制标识0x
//        }
//        //需要比较的校验和值
//        Long compare = AccountHelper.StringToLong(info[info.length - 2].replaceAll("0x", "") + info[info.length - 1].replaceAll("0x", ""), 16);
//        return result.equals(compare);
//    }
//
//    /**
//     * 物理层原始报文处理
//     * 名称	帧头	协议版本	数据区长度	功能码	帧id	  数据区	     校验码
//     * 字节长度	 1	     1	       2	    1	     1	      0~1000	   2
//     * 位置	1	    2	      3~4	   5	    6	      7~N-2	     N-1~N
//     *
//     * @param data 原始协议报文数据 示例 0xa5 0x00 0x00 0x00 0x00 0x12 0x00 0xB7
//     * @return map key:协议帧名称  value:帧对应的值
//     */
//    public static Map<String, String> getOrgAllData(String data) {
//        Map<String, String> map = new HashMap<String, String>();
//        if (StringUtils.isEmpty(data)) {
//            return null;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        List<String> list = new ArrayList<String>();
//        for (String s : info) {
//            s = s.replaceAll("0x", "");//去掉16进制标识0x
//            list.add(s);
//        }
//        map.put("zt", list.get(0));//帧头
//        map.put("xybb", list.get(1));//协议版本
//        map.put("sjcd", list.get(2) + list.get(3));//数据区长度
//        map.put("glm", list.get(4));//功能码
//        map.put("zid", list.get(5));//zid
//        StringBuffer msg = new StringBuffer();
//        for (int i = 6; i < list.size() - 2; i++) {//数据区从第7位到倒数第三位，长度为动态 如果数据区长度为0 则表示没有数据区数据
//            //协议数据区数据是进行亦或加密处理，需要再进行异或获取真实值
//            msg.append(getRealData(list.get(i), XOR_FLAG));
//            msg.append(" ");//应用层协议字节可能达到1000，这里有数据需要另外解析处理，所以暂时用空格隔离保持原数据格式
//        }
//        map.put("data", msg.toString());//原始数据
//        map.put("jxm", list.get(list.size() - 2) + list.get(list.size() - 1));//校验码
//        return map;
//    }
//
//    /**
//     * 运用层原始报文处理（ 该层协议数据放入物理层通信协议数据帧的数据区即有效载荷区.单次传输长度不得超过1000个字节）
//     * 位置	长度	数据体                   说明
//     * 1	1	版本                       0 表示第0版当前为第0版
//     * 2	1	设备ID长度         假设值为n
//     * 3~17	15	设备ID      设备id出厂时候确定
//     * 18	1	设备验证码            假设值为M
//     * 19~33	15	设备验证码            当前版本采用设备ID与0x55异或所得
//     * N+m+k+12   k	可变数据体            根据实际情况确定
//     *
//     * @param data 原始运行层协议报文数据  示例： 0x00 0x05  0xXX 0xXX 0xXX 0xXX 0xXX 0x05 0xXX 0xXX 0xXX 0xXX 0xXX  0xXX  0xXX  0xXX
//     * @return map key:协议帧名称  value:帧对应的值
//     */
//    public static Map<String, String> getOrgUseData(String data) {
//        Map<String, String> map = new HashMap<String, String>();
//        if (StringUtils.isEmpty(data)) {
//            return null;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        List<String> list = Arrays.asList(info);
//        map.put("xybb", list.get(0));//版本
//        map.put("idcd", list.get(1));//设备ID长度
//        StringBuffer temp = new StringBuffer();
//        for (int i = 2; i < 17; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("id", temp.toString());//设备ID
//        map.put("yzmcd", list.get(17));//设备验证码长度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 18; i < 33; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("yzm", temp.toString());//设备验证码
//        //清除暂存区长度
//        temp.delete(0, temp.length());
//        for (int i = 33; i < list.size(); i++) { //最终数据还需要解析，所以保持原始格式
//            temp.append(list.get(i));
//            temp.append(" ");
//        }
//        map.put("data", temp.toString());//最终使用的数据
//        return map;
//    }
//
//
//    /**
//     * 获取箱体押运信息
//     * 位置	长度	数据体	备注和说明
//     * 1	1	0	           指令头
//     * 2~6	5	时间戳	1970-1-1 8:0:0，到当前时间的秒数。高字节在前，java后台有现成转换程序http://www.beijing-time.org/shijianchuo/
//     * 7~10	4	经度	实际经度值*1000000发送 ，高字节在前   0表示没有获取到
//     * 11~14	4	维度	实际值*1000000发送， 高字节在前   0 表示没有获取到
//     * 15	1	电池容量	电池的容量范围  0~100；  实际为电容容量的百分数
//     * 16	1	押运物数量	箱体中包含押运物数量
//     * 17	1	押运方式	押运方式 具体参数值暂时不定义
//     * 18	1	通信方式	0：表示4g通信 1：表示nb通信其他值保留
//     * 19	1	信号强度	实际信号强度+150后发送。如果传输50，  50-150=-100，即信号强度为-100dbm。
//     * 20	1	定位方式	 0表示没有定位，1表示gps定位，2表示基站定位 其他值保留
//     *
//     * @param data 从运行层原始报文中获取的可变数据体
//     * @return map key:协议帧名称  value:帧对应的值
//     */
//    public static Map<String, String> getEquipmentTransportData(String data) {
//        Map<String, String> map = new HashMap<String, String>();
//        if (StringUtils.isEmpty(data)) {
//            return null;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        List<String> list = Arrays.asList(info);
//        map.put("head", list.get(0));//指令头
//        StringBuffer temp = new StringBuffer();
//        for (int i = 1; i < 6; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("date", temp.toString());//时间戳
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 6; i < 10; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_lon", temp.toString());//经度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 10; i < 14; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_la", temp.toString());//纬度
//        map.put("energy", list.get(14));//电池容量
//        map.put("samples", list.get(15));//押运物数量
//        map.put("transport", list.get(16));//押运方式
//        map.put("messenge", list.get(17));//通信方式
//        map.put("signal", list.get(18));//信号强度
//        map.put("type", list.get(19));//定位方式
//        return map;
//    }
//
//
//    /**
//     * 获取锁箱信息
//     * 位置	长度	数据体	备注和说明
//     * 1	1	1	指令
//     * 2~6	5	时间戳	查看箱体押运信息时间戳
//     * 7	1	锁箱方式	押运物锁箱的方式 0 ：表示手持锁定箱体，1：远程锁箱；2：表示只有锁箱权限IC卡锁箱，3：双权限IC锁箱。其他值保留
//     * 20200530 v1.2.1版本协议将该信息删除  8	1	押运方式	押运方式 具体参数值暂时不定义
//     * 8	1	电池电量	电池的电量范围  0~100；  实际为电容电量的百分数
//     * 9	1	定位方式	0表示定位失败 1表示gps定位 2表示基站定位 其他值保留
//     * 10~13	4	锁箱经度	对比箱体押运信息经度， 如果为0 表示没有获取到
//     * 14~17	4	锁箱维度	对比箱体押运信息维度， 如果为0 表示没有获取到
//     * 18	1	锁箱人 标识长度	锁箱人标识长度，用于确定锁箱人标识的长度 假设为n 范围1~40
//     * 19~19+n	N	锁箱人标识	可以为ascii字符，也可以为名字
//     *
//     * @param data 从运行层原始报文中获取的可变数据体
//     * @return map key:协议帧名称  value:帧对应的值
//     */
//    public static Map<String, String> getEquipmentClockData(String data) {
//        Map<String, String> map = new HashMap<String, String>();
//        if (StringUtils.isEmpty(data)) {
//            return null;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        List<String> list = Arrays.asList(info);
//        map.put("head", list.get(0));//指令头
//        StringBuffer temp = new StringBuffer();
//        for (int i = 1; i < 6; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("date", temp.toString());//时间戳
//        map.put("clock_type", list.get(6));//锁箱方式
//        //	map.put("transport", list.get(7));//押运方式  20200530 v1.2.1版本协议将该信息删除
//        map.put("energy", list.get(7));//电池容量
//        map.put("type", list.get(8));//定位方式
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 9; i < 13; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_lon", temp.toString());//经度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 13; i < 17; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_la", temp.toString());//纬度
//        map.put("person_len", list.get(17));//锁箱人标识长度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 18; i < list.size(); i++) {
//            temp.append(list.get(i));
//        }
//        map.put("person", temp.toString());//锁箱人标识长度
//        return map;
//    }
//
//
//    /**
//     * 获取开箱信息
//     * 位置	长度	数据体	    备注和说明
//     * 1	     1	     2	         指令
//     * 2~6	    4	   时间戳	    查看箱体押运信息时间戳
//     * 7	    1	 开箱方式	  	押运物开箱方式。0：表示手持机开箱； 1：表示远程开箱；2：表示只有开箱权限IC卡开箱；3：双权限IC卡开箱  其他值保留
//     * 8	    1	 电池电量		电池的电量范围  0~100；  实际为电容电量的百分数
//     * 9	    1	 定位方式		0表示定位失败，1表示gps定位，2表示基站定位 其他值保留
//     * 10~13	   4	 开箱经度		对比箱体押运信息经度， 如果为0 表示没有获取到
//     * 14~17	   4	 开箱维度		对比箱体押运信息维度， 如果为0 表示没有获取到
//     * 18	   1	 开箱人标识长度	开箱人标识长度，用于确定开箱人标识的长度 假设为n 范围1~40
//     * 19~n+19	   n	 开箱人标识		可以为ascii字符，也可以为名字
//     *
//     * @param data 从运行层原始报文中获取的可变数据体
//     * @return map key:协议帧名称  value:帧对应的值
//     */
//    public static Map<String, String> getEquipmentOpenData(String data) {
//        Map<String, String> map = new HashMap<String, String>();
//        if (StringUtils.isEmpty(data)) {
//            return null;
//        }
//        String[] info = data.split(" {1,}");//以空格进行截取
//        List<String> list = Arrays.asList(info);
//        map.put("head", list.get(0));//指令头
//        StringBuffer temp = new StringBuffer();
//        for (int i = 1; i < 6; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("date", temp.toString());//时间戳
//        map.put("open_type", list.get(6));//开箱方式
//        map.put("energy", list.get(7));//电池容量
//        map.put("type", list.get(8));//定位方式
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 9; i < 13; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_lon", temp.toString());//经度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 13; i < 17; i++) {
//            temp.append(list.get(i));
//        }
//        map.put("gps_la", temp.toString());//纬度
//        map.put("person_len", list.get(17));//锁箱人标识长度
//        //清除暂存区数据
//        temp.delete(0, temp.length());
//        for (int i = 18; i < list.size(); i++) {
//            temp.append(list.get(i));
//        }
//        map.put("person", temp.toString());//锁箱人标识长度
//        return map;
//    }
//
//    /**
//     * 获取运行层数据区原始数据
//     *
//     * @param data 原始物理层协议数据
//     * @return map key:1  value：运行层数据区原始协议数据
//     * 2                         箱体ID
//     * -1                         错误提示
//     */
//    public static Map<Integer, String> getNeedData(String data) {
//        Map<Integer, String> map = new HashMap<Integer, String>();
//        //原始包含物理层和运行层协议
//        Map<String, String> map_all = WzxDataHelper.getOrgAllData(data);
//        String all_data = map_all.get("data");
//        Long sj_len = AccountHelper.StringToLong(map_all.get("sjcd"), 16);
//        if (sj_len == 0 && StringUtils.isEmpty(all_data)) {//协议中数据区长度为0，且取出数据区为空
//            map.put(-1, "No data in physical layer data area");
//            return map;
//        }
//        //运行层协议
//        Map<String, String> map_use = WzxDataHelper.getOrgUseData(all_data);
//        String use_data = map_use.get("data");
//        if (StringUtils.isEmpty(use_data)) {
//            map.put(-1, "No data in application layer data area");
//            return map;
//        } else {
//            map.put(1, use_data);
//            map.put(2, map_use.get("id"));
//            return map;
//        }
//    }
//
//}
//
